package com.qianfeng.stream;

//
//                            _ooOoo_
//                           o8888888o
//                           88" . "88
//                           (| -_- |)
//                            O\ = /O
//                        ____/`---'\____
//                      .   ' \\| |// `.
//                       / \\||| : |||// \
//                     / _||||| -:- |||||- \
//                       | | \\\ - /// | |
//                     | \_| ''\---/'' | |
//                      \ .-\__ `-` ___/-. /
//                   ___`. .' /--.--\ `. . __
//                ."" '< `.___\_<|>_/___.' >'"".
//               | | : `- \`.;`\ _ /`;.`/ - ` : | |
//                 \ \ `-. \_ __\ /__ _/ .-` / /
//         ======`-.____`-.___\_____/___.-`____.-'======
//                            `=---='
//
//         .............................................
//                  佛祖镇楼                  BUG辟易
//          佛曰:
//                  写字楼里写字间，写字间里程序员；
//                  程序人员写程序，又拿程序换酒钱。
//                  酒醒只在网上坐，酒醉还来网下眠；
//                  酒醉酒醒日复日，网上网下年复年。
//                  但愿老死电脑间，不愿鞠躬老板前；
//                  奔驰宝马贵者趣，公交自行程序员。
//                  别人笑我忒疯癫，我笑自己命太贱；
//


import com.qianfeng.pojo.Item;
import com.qianfeng.pojo.Order;
import com.qianfeng.pojo.User;

import java.util.ArrayList;
import java.util.Random;

/**
 * Created by Jackiechan on 2022/10/17 11:25
 * 流式操作,java中提供了一个Stream来帮我们操作集合,主要是做内部迭代,所以简单点说,stream中的操作都是在迭代集合,for循环属于外部迭代
 * 只不过stream额外提供了一些操作
 *
 * @author Jackiechan
 * @version 1.0
 * @since 1.0
 */
public class SteamTest {
    public static void main(String[] args) {
        //模拟生成了一个list集合
        ArrayList<User> list = new ArrayList<>();
        for (int i = 0; i < 20; i++) {
            User user = new User();
            user.setId(i + 1);
            user.setName("张三" + (i + 1));
            user.setAge(10 + i);
            list.add(user);
        }
        //我想把年龄大于等于18岁的人单独放到一个集合中
//        ArrayList<User> list1 = new ArrayList<>();
//        for (User user : list) {
//            if (user.getAge() >= 18) {
//                list1.add(user);
//            }
//        }
//        System.err.println(list1);
        //====华丽的分割线============================
//        List<User> userList = list.stream()
//                //filter做过滤用的,凡是返回true就会保留,false丢弃
//                .filter(user -> user.getAge() >= 19)
//                .collect(Collectors.toList());//将上面的数据保存到一个集合中并返回
//        System.err.println(userList);
        //====华丽的分割线============================
        //count是获取当前数据的数量,这个数据可以是经过N次操作后的数据
        //  System.err.println(list.stream().filter(user -> user.getAge() >= 20).count());
        //====华丽的分割线============================
        //forEach遍历,foreach是终止符,到了foreach之后就不能继续执行后续操作了
        //list.stream().forEach(System.err::println);
        // peek也foreach一样都是在遍历,但是peek不是终止符,可以继续操作数据
        // list.stream().peek(System.err::println).filter(user -> user.getAge() >= 20).forEach(System.err::println);
        //比较  0 相等, <0 是前面的数据小, >0 后面的数据小
//        System.err.println(list.stream().min((u1, u2) -> u1.getAge() - u2.getAge()));
//        System.err.println(list.stream().max((u1, u2) -> u1.getAge() - u2.getAge()));
//        list.stream()
//                .skip(2)//跳过前面几条
//                .limit(2)//保留几条数据
//                .forEach(System.err::println);
        //无限流
        //new Random().ints().limit(10).forEach(System.err::println);

        //华丽的分割线-================================--=-=-=
        //数据转换
        //我想要把所有的学生的名字收集起来

//        ArrayList<String> names = new ArrayList<>();
//        for (User user : list) {
//            String name = user.getName();
//            names.add(name);
//        }
//        System.err.println(names);


//        List<String> collect = list.stream()
//                .map(User::getName)//将数据转成String
//                .collect(Collectors.toList());
//        System.err.println(collect);

        ArrayList<String> allNames = new ArrayList<>();
        for (int i = 0; i < 30; i++) {
            allNames.add("新的名字" + i);
        }


//        ArrayList<User> users = new ArrayList<>();
//        for (String name : allNames) {
//            User user = new User();
//            user.setName(name);
//            users.add(user);
//        }

//        List<User> userList = allNames.stream().map(name -> {
//            User user = new User();
//            user.setName(name);
//            return user;
//        }).collect(Collectors.toList());
//        System.err.println(userList);
        ArrayList<Order> orders = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            Order order = new Order();
            order.setOderId("oid-->" + i);
            order.setPrice(new Random().nextInt(150));
            ArrayList<Item> items = new ArrayList<>();
            for (int i1 = 0; i1 < 20; i1++) {
                Item item = new Item();
                item.setId("item--->" + i + "--->" + i1);
                item.setItemName("华为手机" + i1);
                items.add(item);
                item.setPrice(new Random().nextInt(60));
            }
            order.setItemList(items);
            orders.add(order);
        }

        System.err.println(orders);

//        List<Item> itemList = new ArrayList<>();
//        for (Order order : orders) {
//            itemList.addAll(order.getItemList());
//        }
//
        //flatMap 扁平化的map,首先它是一个map,用作数据转换用,我们有一个集合,集合中的每个数据内部还有一个集合
        //我们可以将每个数据中的集合最后放到一个stream中,这样我们就有了所有的数据
//        List<Item> itemList = orders.stream().flatMap(order -> order.getItemList().stream())
//                .collect(Collectors.toList());
//        System.err.println(itemList);
        //用户的权限  RBAC  role based access control
        //用户--> 角色--->权限
        //一个用户有多个角色,一个角色有多个权限


        //我想要将用户消费金额大于50块钱的所有的订单中的最便宜的那个商品取出来
        //内部迭代,不需要依赖外部数据
//        Item item = orders.stream().filter(order ->{
//                    System.err.println(Thread.currentThread().getName());
//                    return order.getPrice() >= 50;
//                })
//                .flatMap(order -> order.getItemList().stream())
//                .min((item1, item2) -> item1.getPrice() - item2.getPrice())
//                .get();
        //  System.err.println(item);
//        Item item = orders.parallelStream().filter(order ->{
//                    System.err.println(Thread.currentThread().getName());
//                    return order.getPrice() >= 50;
//                })
//                .flatMap(order -> order.getItemList().stream())
//                .min((item1, item2) -> item1.getPrice() - item2.getPrice())
//                .get();


    }
}
